public class Test {
    //算数运算符
    public static void main(String[] args) {
//        System.out.println(5/2);//2
//        System.out.println((float)5/2);//2.5
//        System.out.println(5/(float)2);//2.5
//        System.out.println((float)(5/2));//2.0
//
//
//        System.out.println(10%3);//1
//        System.out.println(10%-3);//1
//        System.out.println(-10%3);//-1
//        System.out.println(-10%-3);//-1
//        System.out.println(11.5%2);//1.5  对小数求余数 整除之后的余数
//        //System.out.println(10/0);//除法和取模时右边的不能是0  否则会出现异常

        //增量运算符
//        int a = 10;
//        a += 10; // --> a = a+10;
//        System.out.println(a);
//
//        long d = 100;
//        int c = 9;
//        //c = c+d;//报错 因为类型不同 要强制类型转换
//        c+=d;// 就可以 c = (int )(c+d)  特点：运算符会帮我们进行类型转换
//        System.out.println(c);

        //自增 自减
//        int a = 10;
//        int b = ++a;//前置 先++ 在使用
//        int c = a++;//后置 先使用 在++
//


        //关系运算符 -- >  结果要么是true 要么是false 结果为真就是true 结果为假就是false
//        int a = 10;
//        int b = 20;
//        System.out.println(a == b);
//        System.out.println(a != b);
//        System.out.println(a<b);
//        System.out.println(a>b);
//        System.out.println(a<=b);
//        System.out.println(a>=b);
//
//        System.out.println(3<a<15);//不能这样 因为a>3为真 是true true不能和15进行比较

        //&& 逻辑与 -- 并且 有假就是假 真为true 假为false
        //|| 逻辑或 -- 或者 有真就是真

        //! 逻辑非   ！布尔表达式  反逻辑 真变成假 假变成真

        //短路求值
//        System.out.println(10>20 && 10/0 ==0);//&& 当表达式1为假就不会执行表达式2了
//        System.out.println(10<20|| 10/0 == 0);//|| 当表达式1为真就不会执行表达式2
//
//        //不建议这样写
//        System.out.println(10>20 & 10/0 == 0);//&也能表示逻辑与 但不能表示短路
//        System.out.println(10<20 | 10/0 == 0);//一样

        //位运算符 -- 针对的是二进制位

        //& 按位与 对应位有0就是0 都是1才为1
        //| 按位或 对应位有1就是1 都是0才为0
        //~ 按位取反 对应二进制位1变成0 0变成1
        //^ 按位异或 对应二进制位相同为0 相异为1
        //n^n == 0   0^n == n

        //移位运算符
        //<< 左移 -- 左侧位不要 右侧补0
        //>> 右移 -- 右侧位不要 左侧补符号位 1为负数 0为正数
        //>>> 无符号右移 -- 右侧不要 左侧补0
        //没有无符号左移

        //条件运算符
//        int a = 10;
//        int b = 20;
//        int max = a>b?a:b; //表达式1是一个布尔表达式
//        System.out.println(max);

//        double x=2.0;
//        int y=4;
//        x/=++y;
//        System.out.println(x);
        
    }

    //字符串类型
    public static void main7(String[] args) {
        //String s1 = "hello";
        //String s2 = "world";
        //String s3 = s1+s2;//这里的+是将两个字符串拼接
        //System.out.println(s3);
        //整数转换成字符串
        //方法1
        int a = 100;
        String s1 = String.valueOf(a);//调用String这个类型的库方法(函数) 这个valueOf这个库方法只要给一个整数就会转换成对应的字符串
        System.out.println(s1);
        //方法2
        String s2 = a + "";//""里面包含的是字符串 整数+字符串这个+就是拼接的意思 会把a里的数据转换成字符串
        System.out.println(s2);

        String s3 = 10+20+"hello";  //先计算整型 整型在和字符串在拼接
        String s4 = "hello"+10+20;  //先计算字符串和整数拼接 得到一个字符串 在和一个整数拼接 所以结果不一样 要注意先计算什么
        System.out.println(s3);//30hello
        System.out.println(s4);//hello1020

        //字符串转换成整数
        String str3 = "10009";
        //方法1 调用Integer这个类的库方法 -- valueOf
        //int ret = Integer.valueOf(str3);//调用Integer这个类的库方法实现转换
        //System.out.println(ret+1);
        //方法2 调用Integer这个类的库方法 -- parseInt
        int ret2 = Integer.parseInt(str3);
        System.out.println(ret2+1);
        //java一般通过.来调用方法
    }
    //类型提升 数据类型小的提升为数据类型大的
    public static void main6(String[] args) {
        int a = 10;
        long b = 20;
        int c = (int)(a+b);//a+b a是int类型 b是long类型 类型提升 把int类型提升为long类型 所以a+b整体是long类型的 放在int c；里面
                           //要强制类型转换成int类型
        byte b1 = 125;
        byte b2 = 123;
        //小于4字节的数据 会提升为int类型进行计算
        byte b3 = (byte)(b1+b2);//强制类型转换 这样表示可以 超出了取值范围会丢失数据 发生截断 数据就不是我们想要的 结果是-8
        System.out.println(b3);//-8
        int b4 = b1+b2;//这样就不会发生截断了
        System.out.println(b4);
    }
    //类型转换
    public static void main5(String[] args) {
        int a = 10;
        long b = 100L;
        //a = b;//java是直接报错的 不能把8个字节的数据赋值给4字节的类型
        a = (int)b;//用强制类型转换 -- 显示类型转换
        b = a;//数据类型占用空间小的转换为大的 这里将a赋值给b  把int类型转换成long类型  隐式类型转换

        //byte c = 256;//报错 256超过了byte的范围 所以不能超过表示的范围
        byte c = (byte)256;//这种是可以的 256默认是int类型 超出了byte的表示范围 强制类型转换了是可以这样写的 但这样数据会丢失
        byte c2 = 127;//这种是没有超出表示范围的
    }
    //布尔型变量
    public static void main4(String[] args) {
        //布尔类型自由true为真和false为假  没有1为真 0为假 不能赋值整数  不能和任何类型进行转换
        boolean fla = true;
        boolean fla2 = false;
        System.out.println(fla);
        //包装类型 Boolean
    }
    //字符类型
    public static void main3(String[] args) {
        char ch = 'A';//2字节
        System.out.println(ch);
        char ch2 = '流';//一个汉字是2个字节  char类型正好是2字节 可以存放汉字  把这个汉字当作字符
        System.out.println(ch2);
        //Character  char的包装类型
        System.out.println(Character.MAX_VALUE);
        System.out.println(Character.MIN_VALUE);
    }


    //浮点型
    public static void main2(String[] args) {
        int a = 1;
        int b = 2;
        System.out.println(a/b);//0  这个int类型在程序上 不能保存小数
        //精确到xxx位
        double num = 1.1;
        System.out.println(num*num);

        float f = 12.5f;//定义float类型的数据要加f  java里认为12.5是double类型的 加个f就代表是float类型 4字节
        System.out.println(f);

    }
    //整型
    public static void main1(String[] args) {
        System.out.println("hello");
        int a = 10;//局部变量一定要先定义赋值在使用
        System.out.println(a);
        //长整型 8字节 与操作系统多少位没有关系
        long b = 10L;//大写的L代表他是长整型
        System.out.println(b);
        System.out.println(Long.MIN_VALUE);//long的最小值
        System.out.println(Long.MAX_VALUE);//long的最大值

        short sh = 10;//短整型 2个字节
        System.out.println(Short.MAX_VALUE);
        System.out.println(Short.MIN_VALUE);

        byte f = 10;//字节类型  1字节
        System.out.println(Byte.MAX_VALUE);
        System.out.println(Byte.MIN_VALUE);

        double d = 12.5;//8字节
        System.out.println(d);
        System.out.println(Double.MIN_VALUE);//输出的是浮点数最小的一个非负整数
        System.out.println(Double.MAX_VALUE);


    }
}
